#include <typeinfo>
#include <cassert>
#include <array>
#include <iostream>
#include <any>
#include <string>
#include <unistd.h>
namespace czy
{
    class Any
    {
        class holder
        {
        public:
            virtual ~holder() {};
            virtual const std::type_info &type() = 0;
            virtual holder *clone() = 0;
        };

        template <typename T>
        class placeholder : public holder
        {
        public:
            placeholder(const T &val) : _val(val) {}
            const std::type_info &type() override { return typeid(T); }
            // 这里回调用T拷贝构造
            holder *clone() override { return new placeholder<T>(_val); }
            T _val;
        };

    private:
        holder *_ptr;

    public:
        Any() : _ptr(nullptr) {}
        Any &swap(Any &other)
        {
            std::swap(_ptr, other._ptr);
            return *this;
        }
        // Any a=9  Any b("csafd")
        template <typename T>
        Any(const T &val) : _ptr(new placeholder<T>(val)) {}
        // 拷贝构造 注意这里深拷贝 如果我们直接把this->_ptr赋值为other._ptr就是浅拷贝
        // 拷贝构造一定要加引用

        Any(const Any &other) { _ptr = other._ptr ? other._ptr->clone() : nullptr; }

        // 拿到保存的数据指针
        template <typename T>
        T *GetVal()
        {
            assert(_ptr->type() == typeid(T));
            return &(((placeholder<T> *)_ptr)->_val);
        }

        template <typename T>
        Any& operator=(const T &val)
        {
            Any(val).swap(*this);
            return *this;
        }
        Any& operator=(const Any &other)
        {
            Any(other).swap(*this);
            return *this; // 这里会发生一次any的拷贝构造 拷贝
        }
        ~Any()
        {
            delete _ptr;
        }
    };
}

class Test
{
public:
    Test() { std::cout << "构造" << std::endl; }
    Test(const Test &t) { std::cout << "拷贝" << std::endl; }
    ~Test() { std::cout << "析构" << std::endl; }
};

int main()
{
    std::any a;//c++ 17提供的
    a = 10;
    int *pi = std::any_cast<int>(&a);
    std::cout << *pi << std::endl;

    a = std::string("hello");
    std::string *ps = std::any_cast<std::string>(&a);
    std::cout << *ps << std::endl;
    return 0;

}




// int main()
// {

//     // std::any a;
//     // a = 10;
//     // int *pi = std::any_cast<int>(&a);
//     // std::cout << *pi << std::endl;

//     // a = std::string("hello");
//     // std::string *ps = std::any_cast<std::string>(&a);
//     // std::cout << *ps << std::endl;

//     //czy::Any a; // 调用any的无参构造
//     {
//         czy::Any a; // 调用any的无参构造
//         Test t;     // 构造
//         a = t;      // 调用any得赋值重载函数 接着后调用t得拷贝构造函数
//     }

//     // a = 10;
//     // int *pa = a.GetVal<int>();
//     // std::cout << *pa << std::endl;
//     // a = std::string("nihao");
//     // std::string *ps = a.GetVal<std::string>();
//     // std::cout << *ps << std::endl;

//     // while (1)
//     //     sleep(1);
//     return 0;
// }